Java 读书笔记 21.2 并发

并发

public abstract class IntGenerator {
    private volatile boolean canceled = false;
    public abstract int next();
    // Allow this to be canceled:
    public void cancel() { canceled = true; }
    public boolean isCanceled() { return canceled; }
}

public class EvenChecker implements Runnable {
    private IntGenerator generator;
    private final int id;
    public EvenChecker(IntGenerator g, int ident) {
        generator = g;
        id = ident;
    }
    public void run() {
        while(!generator.isCanceled()) {
            int val = generator.next();
            //System.out.println(val);
            if(val % 2 != 0) {
                System.out.println(val + " not even!");
                generator.cancel(); // Cancels all EvenCheckers
            }
        }
    }
    // Test any type of IntGenerator:
    public static void test(IntGenerator gp, int count) {
        System.out.println("Press Control-C to exit");
        ExecutorService exec = Executors.newCachedThreadPool();
        for(int i = 0; i < count; i++)
            exec.execute(new EvenChecker(gp, i));
        exec.shutdown();
    }
    // Default value for count:
    public static void test(IntGenerator gp) {
        test(gp, 10);
    }
}

public class EvenGenerator extends IntGenerator {
    private int currentEvenValue = 0;
    public  synchronized  int next() {
        ++currentEvenValue;    //简单地说synchronized关键字将next（）锁了起来，
                              //加两次的中间是不会被的线程抢走；
        Thread.yield();
        ++currentEvenValue;
        return currentEvenValue;
    }
    public static void main(String[] args) {
        EvenChecker.test(new EvenGenerator());

    }
}

或者通过显式的lock关键字

  
public class MutexEvenGenerator extends IntGenerator {  
  private int currentEvenValue = 0;  
  private Lock lock = new ReentrantLock();  
  public int next() {  
    lock.lock();  
    try {  
      ++currentEvenValue;  
      Thread.yield(); // Cause failure faster  
      ++currentEvenValue;  
      return currentEvenValue;  
    } finally {  
      lock.unlock();  
    }  
  }  
  public static void main(String[] args) {  
    EvenChecker.test(new MutexEvenGenerator());  
  }  
}

你可能发现lock要写好多东西，这也是java的思想，宁愿写的多，也舒服，非常明显的锁和释放，而且更细

import java.util.concurrent.*;  
import java.util.concurrent.locks.*;  
  
public class AttemptLocking {  
  private ReentrantLock lock = new ReentrantLock();  
  public void untimed() {  
    boolean captured = lock.tryLock();  
    try {  
      System.out.println("tryLock(): " + captured);  
    } finally {  
      if(captured)  
        lock.unlock();  
    }  
  }  
  public void timed() {  
    boolean captured = false;  
    try {  
      captured = lock.tryLock(2, TimeUnit.SECONDS);  
    } catch(InterruptedException e) {  
      throw new RuntimeException(e);  
    }  
    try {  
      System.out.println("tryLock(2, TimeUnit.SECONDS): " +  
        captured);  
    } finally {  
      if(captured)  
        lock.unlock();  
    }  
  }  
  public static void main(String[] args) {  
    final AttemptLocking al = new AttemptLocking();  
    al.untimed(); // True -- lock is available  
    al.timed();   // True -- lock is available  
    // Now create a separate task to grab the lock:  
    new Thread() {  
      { setDaemon(true); }  
      public void run() {  
        al.lock.lock();  
        System.out.println("acquired");  
      }  
    }.start();  
    Thread.yield(); // Give the 2nd task a chance  
    al.untimed(); // False -- lock grabbed by task  
    al.timed();   // False -- lock grabbed by task  
  }

当线程被锁起来，下面两个函数虽然拿不到锁，但是还可以做别的；

原子性